Avtentikacija v Python Django: Obvladovanje modelov za uporabnike po meri za globalne aplikacije

Privzgrajeni sistem za avtentikacijo v Django je močna iztočnica za številne spletne aplikacije. Vendar pa, ko se vaša aplikacija razširja in postaja bolj zapletena, še posebej za globalno občinstvo, privzeti uporabniški model morda ne bo zadostoval. Tu nastopijo uporabniški modeli po meri, ki ponujajo večjo prilagodljivost in nadzor nad podatki uporabnikov ter postopki avtentikacije. Ta obširen vodnik vas bo popeljal skozi postopek ustvarjanja in implementacije uporabniških modelov po meri v Django, s čimer boste zagotovili, da bo vaša aplikacija dobro opremljena za obravnavo raznolikih zahtev uporabnikov in varnostnih vidikov.

Zakaj uporabiti uporabniški model po meri?

Privzeti uporabniški model Django je zasnovan s skupnimi atributi, kot so uporabniško ime, geslo, e-pošta, ime in priimek. Medtem ko je primeren za preproste aplikacije, pogosto ne zadošča, ko morate:

• Shraniti dodatne podatke o uporabniku: Razmislite o globalni platformi za e-poslovanje, ki mora shranjevati uporabniške preference, naslove v različnih formatih, želene valute ali nastavitve jezika. Te so izven obsega privzetega modela.
• Spremeniti polje za avtentikacijo: Morda želite avtenticirati uporabnike z njihovo e-pošto namesto z uporabniškim imenom ali implementirati večfaktorsko avtentikacijo, ki zahteva dodatna polja.
• Integrirati z obstoječimi bazami podatkov: Če integrirate aplikacijo Django z obstoječo bazo podatkov, ki ima drugačno shemo uporabnikov, vam uporabniški model po meri omogoča, da svoj model preslikate v obstoječo podatkovno strukturo.
• Izboljšati varnost: Modeli po meri omogočajo večji nadzor nad hashiranjem gesel, mehanizmi za ponastavitev gesla in drugimi vidiki, povezanimi z varnostjo.
• Implementirati različne vloge uporabnikov: Shranjevanje podatkov za nadzor dostopa na podlagi vlog (RBAC) neposredno v modelu (ali njihovo sklicevanje) ponuja bolj prilagodljiv in jasen nadzor kot splošne skupine in dovoljenja.

Uporaba uporabniškega modela po meri zagotavlja čist in vzdrževalen način za razširitev uporabniškega profila brez neposredne spreminjanja osnovnega sistema avtentikacije Django. To je najboljša praksa za vsak projekt, ki predvideva prihodnjo rast ali zahteva specializirane uporabniške podatke.

Kdaj implementirati uporabniški model po meri?

Najboljši čas za implementacijo uporabniškega modela po meri je na začetku vašega projekta. Spreminjanje uporabniškega modela v produkcijskem okolju je lahko zapleteno in potencialno škodljivo za podatke. Če je vaš projekt že v teku, natančno pretehtajte posledice in ustvarite robusten načrt migracije, preden naredite kakršne koli spremembe.

Tukaj je splošno vodilo:

• Začnite z uporabniškim modelom po meri: Če predvidevate kakršno koli potrebo po razširjenih uporabniških podatkih ali logiki avtentikacije po meri.
• Skrbno preučite migracijo: Če že imate delujoč projekt Django z uporabniki in se odločite za prehod na model po meri. Varnostno kopirajte svojo bazo podatkov in temeljito razumite postopek migracije.

Ustvarjanje uporabniškega modela po meri

Obstajata dva glavna pristopa k ustvarjanju uporabniškega modela po meri v Django:

1. AbstractBaseUser: Ta pristop vam daje popoln nadzor nad uporabniškim modelom. Definirate vsa polja, vključno z uporabniškim imenom, geslom, e-pošto in vsemi polji po meri, ki jih potrebujete.
2. AbstractUser: Ta pristop podeduje od privzetega uporabniškega modela Django in vam omogoča dodajanje ali spreminjanje obstoječih polj. To je lažje, če morate dodati le nekaj dodatnih polj.

1. Uporaba AbstractBaseUser (popoln nadzor)

To je najbolj prilagodljiva možnost, ki vam omogoča, da celoten uporabniški model definirate od začetka. Zagotavlja največji nadzor nad strukturo uporabniških podatkov in postopkom avtentikacije. Tukaj je, kako:

Korak 1: Ustvarite uporabniški model po meri

V svoji aplikaciji Django (npr. 'accounts') ustvarite datoteko `models.py` in definirajte svoj uporabniški model po meri, ki podeduje od `AbstractBaseUser` in `PermissionsMixin`:

            from django.db import models
from django.contrib.auth.models import AbstractBaseUser, PermissionsMixin, BaseUserManager

class CustomUserManager(BaseUserManager):
    def create_user(self, email, password=None, **extra_fields):
        if not email:
            raise ValueError('The Email field must be set')
        email = self.normalize_email(email)
        user = self.model(email=email, **extra_fields)
        user.set_password(password)
        user.save(using=self._db)
        return user

    def create_superuser(self, email, password, **extra_fields):
        extra_fields.setdefault('is_staff', True)
        extra_fields.setdefault('is_superuser', True)
        extra_fields.setdefault('is_active', True)

        if extra_fields.get('is_staff') is not True:
            raise ValueError('Superuser must have is_staff=True.')
        if extra_fields.get('is_superuser') is not True:
            raise ValueError('Superuser must have is_superuser=True.')

        return self.create_user(email, password, **extra_fields)

class CustomUser(AbstractBaseUser, PermissionsMixin):
    email = models.EmailField(unique=True, verbose_name='email address')
    first_name = models.CharField(max_length=150, blank=True)
    last_name = models.CharField(max_length=150, blank=True)
    is_staff = models.BooleanField(default=False)
    is_active = models.BooleanField(default=True)
    date_joined = models.DateTimeField(auto_now_add=True)

    # Custom fields (Example: preferred language, timezone, etc.)
    preferred_language = models.CharField(max_length=10, default='en', choices=[('en', 'English'), ('fr', 'French'), ('es', 'Spanish')])
    timezone = models.CharField(max_length=50, default='UTC')

    USERNAME_FIELD = 'email'
    REQUIRED_FIELDS = [] # Required when creating a superuser

    objects = CustomUserManager()

    def __str__(self):
        return self.email

            

              
                Copy
              
            
          

Razlaga:

• CustomUserManager: Ta razred je potreben za upravljanje vašega uporabniškega modela po meri. Obravnava ustvarjanje uporabnikov in superuporabnikov. `normalize_email` je pomemben za zagotavljanje doslednosti e-pošte med različnimi lokalnimi nastavitvami in metodami vnosa.
• CustomUser: To je vaš uporabniški model po meri.
• `email = models.EmailField(unique=True, verbose_name='email address')`: Definira polje e-pošte kot edinstveni identifikator uporabnika. Uporaba `unique=True` zagotavlja, da ima vsak uporabnik edinstveno e-poštni naslov. Naziv `verbose_name` izboljša administracijski vmesnik.
• `first_name`, `last_name`: Standardna polja za shranjevanje uporabnikovega imena. `blank=True` omogoča, da so ta polja lahko prazna.
• `is_staff`, `is_active`: Standardna polja za nadzor dostopa uporabnika do skrbniške plošče in aktivacijo računa.
• `date_joined`: Zabeleži datum ustvarjanja uporabniškega računa.
• `preferred_language`, `timezone`: Primer polj po meri za shranjevanje uporabniških preferenc. Argument `choices` omejuje možne jezikovne možnosti. To je ključnega pomena za globalno aplikacijo. Časovni pas je prav tako pomemben za lokalizacijo.
• `USERNAME_FIELD = 'email'`: Določa, da se bo polje e-pošte uporabljalo kot uporabniško ime za avtentikacijo.
• `REQUIRED_FIELDS = []`: Določa polja, ki so obvezna pri ustvarjanju superuporabnika z ukazom `createsuperuser`. V tem primeru poleg e-pošte in gesla niso potrebna dodatna polja.
• `objects = CustomUserManager()`: Dodeljuje upravitelja po meri modelu.
• `__str__(self)`: Definira, kako je uporabniški objekt predstavljen kot niz (npr. v administracijskem vmesniku).

Korak 2: Posodobite `settings.py`

Django povejte, da uporablja vaš uporabniški model po meri, tako da v datoteko `settings.py` dodate naslednjo vrstico:

            AUTH_USER_MODEL = 'accounts.CustomUser'
            

              
                Copy
              
            
          

Zamenjajte `accounts` z imenom vaše aplikacije, kjer ste definirali model `CustomUser`.

Korak 3: Ustvarite in izvedite migracije

Za ustvarjanje in izvedbo migracij zaženite naslednje ukaze:

            python manage.py makemigrations
python manage.py migrate
            

              
                Copy
              
            
          

To bo ustvarilo novo tabelo v bazi podatkov za vaš uporabniški model po meri.

Korak 4: Uporaba uporabniškega modela po meri

Zdaj lahko uporabniški model po meri uporabljate v svojih pogledih, predlogah in drugih delih aplikacije. Na primer, za ustvarjanje novega uporabnika:

            from accounts.models import CustomUser

user = CustomUser.objects.create_user(email='user@example.com', password='password123', first_name='John', last_name='Doe')
            

              
                Copy
              
            
          

2. Uporaba AbstractUser (dodajanje k privzetemu modelu)

Ta pristop je enostavnejši, če morate samo dodati nekaj dodatnih polj k privzetemu uporabniškemu modelu Django. Podeduje vsa obstoječa polja in metode iz `AbstractUser`. To je lahko lažje za preproste prilagoditve.

Korak 1: Ustvarite uporabniški model po meri

V datoteki `models.py` vaše aplikacije Django definirajte svoj uporabniški model po meri, ki podeduje od `AbstractUser`:

            from django.contrib.auth.models import AbstractUser
from django.db import models

class CustomUser(AbstractUser):
    # Dodajte tukaj dodatna polja
    phone_number = models.CharField(max_length=20, blank=True, verbose_name='Phone Number')
    profile_picture = models.ImageField(upload_to='profile_pictures/', blank=True)
    # Custom fields (Example: preferred currency, address format, etc.)
    preferred_currency = models.CharField(max_length=3, default='USD', choices=[('USD', 'US Dollar'), ('EUR', 'Euro'), ('JPY', 'Japanese Yen')])
    address_format = models.CharField(max_length=50, blank=True, help_text='e.g., "Name, Street, City, Zip, Country"')

    def __str__(self):
        return self.username

            

              
                Copy
              
            
          

Razlaga:

• CustomUser: To je vaš uporabniški model po meri, ki podeduje od `AbstractUser`.
• `phone_number`, `profile_picture`: Primer polj za dodajanje k uporabniškemu modelu. `upload_to` določa, kje bodo shranjene profilne slike.
• `preferred_currency`, `address_format`: Primer polj po meri, ki so pomembna za globalne aplikacije. Različne države imajo drastično različne formate naslovov.
• `__str__(self)`: Definira, kako je uporabniški objekt predstavljen kot niz (npr. v administracijskem vmesniku). Tukaj uporablja uporabniško ime.

Korak 2: Posodobite `settings.py`

Enako kot prej, Django povejte, da uporablja vaš uporabniški model po meri, tako da v datoteko `settings.py` dodate naslednjo vrstico:

            AUTH_USER_MODEL = 'accounts.CustomUser'
            

              
                Copy
              
            
          

Korak 3: Ustvarite in izvedite migracije

Za ustvarjanje in izvedbo migracij zaženite naslednje ukaze:

            python manage.py makemigrations
python manage.py migrate
            

              
                Copy
              
            
          

Korak 4: Uporaba uporabniškega modela po meri

Zdaj lahko dostopate do dodanih polj pri delu z uporabniškimi objekti:

            from accounts.models import CustomUser

user = CustomUser.objects.create_user(username='johndoe', password='password123', email='john.doe@example.com')
user.phone_number = '+15551234567'
user.preferred_currency = 'EUR'
user.save()

            

              
                Copy
              
            
          

Najboljše prakse za uporabniške modele po meri v globalnih aplikacijah

Pri implementaciji uporabniških modelov po meri za aplikacije, usmerjene v globalno občinstvo, upoštevajte naslednje najboljše prakse:

1. Internacionalizacija in lokalizacija (i18n & l10n)

Shranite podatke, specifične za lokalno nastavitev: Zasnovajte svoj model tako, da bo prilagojen različnim kulturnim normam in formatom podatkov. Shranjujte datume, ure, števila in naslove na način, ki upošteva lokalno nastavitev.

Primer:

            from django.utils import timezone

class CustomUser(AbstractUser):
    #...
    date_of_birth = models.DateField(blank=True, null=True)

    def get_localized_date_of_birth(self, language_code):
        if self.date_of_birth:
            return timezone.localtime(timezone.make_aware(datetime.datetime.combine(self.date_of_birth, datetime.time.min))).strftime('%x')  # Format according to the locale
        return None
            

              
                Copy
              
            
          

2. Obravnavanje časovnih pasov

Vedno shranjujte in obravnavajte časovne pasove pravilno. Shranite informacije o časovnem pasu v uporabniški model in jih uporabite za prikazovanje datumov in ur v lokalnem časovnem pasu uporabnika.

Primer:

            from django.utils import timezone

class CustomUser(AbstractUser):
    #...
    timezone = models.CharField(max_length=50, default='UTC')

    def get_localized_time(self, datetime_obj):
        user_timezone = pytz.timezone(self.timezone)
        return timezone.localtime(datetime_obj, user_timezone)

            

              
                Copy
              
            
          

3. Oblikovanje naslovov

Formati naslovov se močno razlikujejo med državami. Implementirajte prilagodljiv sistem naslovov, ki uporabnikom omogoča vnos naslova v pravilnem formatu za njihovo lokacijo. Razmislite o uporabi knjižnice ali storitve tretje osebe za obravnavanje potrjevanja in oblikovanja naslovov.

Primer:

            class CustomUser(AbstractUser):
    #...
    country = models.CharField(max_length=50, blank=True)
    address_line_1 = models.CharField(max_length=255, blank=True)
    address_line_2 = models.CharField(max_length=255, blank=True)
    city = models.CharField(max_length=100, blank=True)
    postal_code = models.CharField(max_length=20, blank=True)

    def get_formatted_address(self):
        # Implement logic to format address based on country
        if self.country == 'US':
            return f'{self.address_line_1}\n{self.address_line_2}\n{self.city}, {self.postal_code}, {self.country}'
        elif self.country == 'GB':
            return f'{self.address_line_1}\n{self.address_line_2}\n{self.city}\n{self.postal_code}\n{self.country}'
        else:
            return 'Address format not supported'

            

              
                Copy
              
            
          

4. Obravnavanje valut

Če vaša aplikacija vključuje finančne transakcije, shranite uporabnikovo želeno valuto in jo uporabite za prikazovanje cen in zneskov. Uporabite knjižnico, kot je `babel`, za oblikovanje valutnih vrednosti v skladu z lokalno nastavitvijo uporabnika.

Primer:

            from babel.numbers import format_currency

class CustomUser(AbstractUser):
    #...
    preferred_currency = models.CharField(max_length=3, default='USD')

    def get_formatted_price(self, amount):
        return format_currency(amount, self.preferred_currency, locale='en_US')  # Adjust locale as needed
            

              
                Copy
              
            
          

5. Potrjevanje podatkov

Implementirajte robustno potrjevanje podatkov, da zagotovite, da so uporabniški vnosi veljavni in dosledni. Uporabite vgrajene validatorje Django ali ustvarite validatorje po meri za zagotavljanje celovitosti podatkov.

Primer:

            from django.core.validators import RegexValidator

class CustomUser(AbstractUser):
    #...
    phone_number = models.CharField(
        max_length=20,
        blank=True,
        validators=[
            RegexValidator(
                regex=r'^\+?\d{9,15}$',
                message="Phone number must be entered in the format: '+999999999'. Up to 15 digits allowed."
            ),
        ]
    )

            

              
                Copy
              
            
          

6. Varnostni vidiki

Hashiranje gesel: Avtentikacijski sistem Django privzeto uporablja močne algoritme za hashiranje gesel. Zagotovite, da uporabljate najnovejšo različico Django, da izkoristite najnovejše varnostne posodobitve.

Dvo-faktorska avtentikacija (2FA): Implementirajte 2FA, da dodate dodatno plast varnosti uporabniškim računom. Za to obstajajo različni paketi Django, kot je `django-otp`. To je še posebej pomembno pri obravnavanju občutljivih uporabniških podatkov ali finančnih transakcij.

Zaščita podatkov: Sledite najboljšim praksam za zaščito podatkov in zasebnost, zlasti pri obravnavanju občutljivih uporabniških informacij. Upoštevajte ustrezne predpise o varstvu podatkov, kot sta GDPR in CCPA. Razmislite o tehnikah šifriranja, anonimizacije in tokenizacije podatkov.

7. Testiranje

Napišite obsežne enotske teste in integracijske teste, da zagotovite, da vaš uporabniški model po meri deluje, kot je pričakovano, in da je vaš avtentikacijski sistem varen. Preizkusite različne scenarije, vključno z veljavnimi in neveljavnimi uporabniškimi vnosi, poteki dela za ponastavitev gesla in preverjanjem dovoljenj.

8. Dokumentacija

Temeljito dokumentirajte svoj uporabniški model po meri in sistem avtentikacije. To bo drugim razvijalcem olajšalo razumevanje in vzdrževanje vaše kode. Vključite informacije o namenu vsakega polja, poteku avtentikacije in morebitnih varnostnih vidikih.

Napredne tehnike in razmisleki

1. Upravljalci uporabnikov po meri

Kot je prikazano v primeru `AbstractBaseUser`, so upravljalci uporabnikov po meri bistveni za ustvarjanje in upravljanje uporabnikov. Omogočajo vam, da definirate logiko po meri za ustvarjanje uporabnikov, kot je nastavitev privzetih vrednosti za določena polja ali izvajanje dodatnega potrjevanja.

2. Posredniki modeli (Proxy Models)

Posredniki modeli vam omogočajo dodajanje metod k uporabniškemu modelu, ne da bi spremenili shemo baze podatkov. To je lahko koristno za dodajanje logike po meri ali izračunov, ki so specifični za vašo aplikacijo.

3. Razširitev uporabniškega modela z modelom profila

Namesto dodajanja številnih polj neposredno k uporabniškemu modelu, lahko ustvarite ločen profilni model, ki ima eno-na-eno povezavo z uporabniškim modelom. To lahko pomaga ohraniti vaš uporabniški model čist in organiziran.

            from django.db import models
from django.conf import settings

class UserProfile(models.Model):
    user = models.OneToOneField(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name='profile')
    # Additional fields
    bio = models.TextField(blank=True)
    location = models.CharField(max_length=100, blank=True)

            

              
                Copy
              
            
          

Ne pozabite ustvariti signala za samodejno ustvarjanje UserProfile, ko je uporabnik ustvarjen:

            from django.db.models.signals import post_save
from django.dispatch import receiver
from django.conf import settings
from .models import UserProfile

@receiver(post_save, sender=settings.AUTH_USER_MODEL)
def create_user_profile(sender, instance, created, **kwargs):
    if created:
        UserProfile.objects.create(user=instance)

@receiver(post_save, sender=settings.AUTH_USER_MODEL)
def save_user_profile(sender, instance, **kwargs):
    instance.profile.save()

            

              
                Copy
              
            
          

4. Enkratna prijava (SSO)

Za večja podjetja ali aplikacije, ki zahtevajo integracijo z drugimi storitvami, razmislite o implementaciji enkratne prijave (SSO) z uporabo protokolov, kot sta OAuth 2.0 ali SAML. Django ponuja več paketov, ki poenostavljajo integracijo SSO, na primer `django-allauth`.

5. Dnevnik revizij (Audit Logging)

Implementirajte dnevnik revizij za sledenje uporabniških dejavnosti in sprememb uporabniških podatkov. To je lahko koristno za varnostno nadzorovanje, skladnost in odpravljanje napak. Paketi, kot je `django-auditlog`, lahko pomagajo avtomatizirati ta postopek.

Zaključek

Ustvarjanje in implementacija uporabniških modelov po meri v Django zagotavlja prilagodljivost in nadzor, ki ju potrebujete za gradnjo robustnih in razširljivih sistemov avtentikacije, še posebej za globalne aplikacije. Z upoštevanjem najboljših praks, opisanih v tem vodniku, lahko zagotovite, da bo vaša aplikacija dobro opremljena za obravnavo raznolikih zahtev uporabnikov, ohranjanje celovitosti podatkov ter zagotavljanje varne in uporabniku prijazne izkušnje za uporabnike po vsem svetu. Ne pozabite skrbno načrtovati svoje implementacije, upoštevati potrebe svojih uporabnikov in dati prednost varnosti v vsaki fazi postopka. Izbira med `AbstractBaseUser` in `AbstractUser` je odvisna od stopnje potrebne prilagoditve. Za bistvene spremembe `AbstractBaseUser` ponuja več nadzora. Za preproste razširitve `AbstractUser` omogoča lažji prehod. Temeljito testiranje je ključnega pomena za zagotovitev, da se uporabniški model po meri brezhibno integrira s preostalo aplikacijo Django in izpolnjuje vse varnostne zahteve. Sprejmite najboljše prakse za internacionalizacijo, lokalizacijo in obravnavanje časovnih pasov, da zagotovite resnično globalno izkušnjo. To bo bistveno prispevalo k uspehu in sprejetju vaše aplikacije na različnih trgih po vsem svetu.